
import { _decorator } from 'cc';
import { BaseModule } from './base/BaseModule';
const { ccclass } = _decorator;

/**
 * 日志级别枚举
 */
export enum LogLevel {
    DEBUG = 0,
    INFO = 1,
    WARN = 2,
    ERROR = 3
}

/**
 * 日志条目接口
 */
interface LogEntry {
    level: LogLevel;
    message: string;
    timestamp: number;
    module?: string;
}

/**
 * 日志系统，用于统一管理游戏中的日志输出
 */
@ccclass('LogSystem')
export class LogSystem extends BaseModule {
 
    // 当前日志级别
    private _currentLevel: LogLevel = LogLevel.DEBUG;
    
    // 日志缓存
    private _logCache: LogEntry[] = [];
    
    // 缓存最大条目数
    private _maxCacheSize: number = 1000;
    
    // 是否输出到控制台
    private _consoleOutput: boolean = true;
    
    // 是否保存到本地存储
    private _localStorage: boolean = true;
    
    // 本地存储键名
    private _storageKey: string = 'game_framework_logs';


    init(): void {
        // 从本地存储加载历史日志
        this.loadLogsFromStorage();
        
        console.log("LogSystem initialized");
    }

    shutdown(): void {
        // 保存日志到本地存储
        this.saveLogsToStorage();
        
        // 清理日志缓存
        this._logCache.length = 0;
        
        console.log("LogSystem shutdown");
    }

    /**
     * 设置日志级别
     * @param level 日志级别
     */
    setLevel(level: LogLevel): void {
        this._currentLevel = level;
    }

    /**
     * 设置是否输出到控制台
     * @param enable 是否启用
     */
    setConsoleOutput(enable: boolean): void {
        this._consoleOutput = enable;
    }

    /**
     * 设置是否保存到本地存储
     * @param enable 是否启用
     * @param maxCacheSize 最大缓存条目数
     */
    setLocalStorage(enable: boolean, maxCacheSize: number = 1000): void {
        this._localStorage = enable;
        this._maxCacheSize = maxCacheSize;
    }

    /**
     * 输出调试日志
     * @param message 日志消息
     * @param module 模块名（可选）
     */
    debug(message: string, module?: string): void {
        this.log(LogLevel.DEBUG, message, module);
    }

    /**
     * 输出信息日志
     * @param message 日志消息
     * @param module 模块名（可选）
     */
    info(message: string, module?: string): void {
        this.log(LogLevel.INFO, message, module);
    }

    /**
     * 输出警告日志
     * @param message 日志消息
     * @param module 模块名（可选）
     */
    warn(message: string, module?: string): void {
        this.log(LogLevel.WARN, message, module);
    }

    /**
     * 输出错误日志
     * @param message 日志消息
     * @param module 模块名（可选）
     */
    error(message: string, module?: string): void {
        this.log(LogLevel.ERROR, message, module);
    }

    /**
     * 记录日志
     * @param level 日志级别
     * @param message 日志消息
     * @param module 模块名（可选）
     */
    private log(level: LogLevel, message: string, module?: string): void {
        // 检查日志级别
        if (level < this._currentLevel) {
            return;
        }

        const entry: LogEntry = {
            level,
            message,
            timestamp: Date.now(),
            module
        };

        // 添加到缓存
        this._logCache.push(entry);
        
        // 限制缓存大小
        if (this._logCache.length > this._maxCacheSize) {
            this._logCache.shift();
        }

        // 输出到控制台
        if (this._consoleOutput) {
            const formattedMessage = module ? `[${module}] ${message}` : message;
            const time = new Date(entry.timestamp).toISOString();
            
            switch (level) {
                case LogLevel.DEBUG:
                    console.debug(`[DEBUG] ${time} ${formattedMessage}`);
                    break;
                case LogLevel.INFO:
                    console.info(`[INFO] ${time} ${formattedMessage}`);
                    break;
                case LogLevel.WARN:
                    console.warn(`[WARN] ${time} ${formattedMessage}`);
                    break;
                case LogLevel.ERROR:
                    console.error(`[ERROR] ${time} ${formattedMessage}`);
                    break;
            }
        }

        // 保存到本地存储
        if (this._localStorage) {
            this.saveLogsToStorage();
        }
    }

    /**
     * 从本地存储加载日志
     */
    private loadLogsFromStorage(): void {
        try {
            const storedLogs = localStorage.getItem(this._storageKey);
            if (storedLogs) {
                const logs: LogEntry[] = JSON.parse(storedLogs);
                this._logCache = logs;
            }
        } catch (e) {
            console.error('Failed to load logs from local storage:', e);
        }
    }

    /**
     * 保存日志到本地存储
     */
    private saveLogsToStorage(): void {
        try {
            localStorage.setItem(this._storageKey, JSON.stringify(this._logCache));
        } catch (e) {
            console.error('Failed to save logs to local storage:', e);
        }
    }

    /**
     * 获取指定级别的日志
     * @param level 日志级别
     * @returns 日志条目数组
     */
    getLogsByLevel(level: LogLevel): LogEntry[] {
        return this._logCache.filter(entry => entry.level === level);
    }

    /**
     * 获取指定模块的日志
     * @param module 模块名
     * @returns 日志条目数组
     */
    getLogsByModule(module: string): LogEntry[] {
        return this._logCache.filter(entry => entry.module === module);
    }

    /**
     * 获取所有日志
     * @returns 日志条目数组
     */
    getAllLogs(): LogEntry[] {
        return [...this._logCache];
    }

    /**
     * 清除所有日志
     */
    clearLogs(): void {
        this._logCache.length = 0;
        try {
            localStorage.removeItem(this._storageKey);
        } catch (e) {
            console.error('Failed to clear logs from local storage:', e);
        }
    }

    /**
     * 导出日志为文本
     * @returns 日志文本
     */
    exportLogs(): string {
        return this._logCache.map(entry => {
            const levelStr = LogLevel[entry.level];
            const time = new Date(entry.timestamp).toISOString();
            const moduleStr = entry.module ? `[${entry.module}]` : '';
            return `[${levelStr}] ${time} ${moduleStr} ${entry.message}`;
        }).join('\n');
    }
}